home *** CD-ROM | disk | FTP | other *** search
/ OpenGL Superbible (2nd Edition) / OpenGL SuperBible e2.iso / tools / Mesa-3.0 / SRC / ENABLE.C < prev    next >
Encoding:
C/C++ Source or Header  |  1998-09-01  |  18.6 KB  |  655 lines
  1. /* $Id: enable.c,v 3.5 1998/09/01 03:07:37 brianp Exp $ */
  2.  
  3. /*
  4.  * Mesa 3-D graphics library
  5.  * Version:  3.0
  6.  * Copyright (C) 1995-1998  Brian Paul
  7.  *
  8.  * This library is free software; you can redistribute it and/or
  9.  * modify it under the terms of the GNU Library General Public
  10.  * License as published by the Free Software Foundation; either
  11.  * version 2 of the License, or (at your option) any later version.
  12.  *
  13.  * This library is distributed in the hope that it will be useful,
  14.  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  15.  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  16.  * Library General Public License for more details.
  17.  *
  18.  * You should have received a copy of the GNU Library General Public
  19.  * License along with this library; if not, write to the Free
  20.  * Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  21.  */
  22.  
  23.  
  24. /*
  25.  * $Log: enable.c,v $
  26.  * Revision 3.5  1998/09/01 03:07:37  brianp
  27.  * references to texture coords now indexed by ctx->TexCoordSet
  28.  *
  29.  * Revision 3.4  1998/03/28 03:58:30  brianp
  30.  * removed unneeded break
  31.  *
  32.  * Revision 3.3  1998/02/20 04:50:44  brianp
  33.  * implemented GL_SGIS_multitexture
  34.  *
  35.  * Revision 3.2  1998/02/08 20:18:20  brianp
  36.  * removed unneeded headers
  37.  *
  38.  * Revision 3.1  1998/02/01 16:37:19  brianp
  39.  * added GL_EXT_rescale_normal extension
  40.  *
  41.  * Revision 3.0  1998/01/31 20:51:23  brianp
  42.  * initial rev
  43.  *
  44.  */
  45.  
  46.  
  47. #ifdef PC_HEADER
  48. #include "all.h"
  49. #else
  50. #include <string.h>
  51. #include "context.h"
  52. #include "enable.h"
  53. #include "light.h"
  54. #include "macros.h"
  55. #include "types.h"
  56. #include "vbfill.h"
  57. #endif
  58.  
  59.  
  60.  
  61. /*
  62.  * Perform glEnable and glDisable calls.
  63.  */
  64. static void gl_enable( GLcontext* ctx, GLenum cap, GLboolean state )
  65. {
  66.    GLuint texSet = ctx->Texture.CurrentSet;
  67.    GLuint p;
  68.  
  69.    if (INSIDE_BEGIN_END(ctx)) {
  70.       if (state) {
  71.      gl_error( ctx, GL_INVALID_OPERATION, "glEnable" );
  72.       }
  73.       else {
  74.      gl_error( ctx, GL_INVALID_OPERATION, "glDisable" );
  75.       }
  76.       return;
  77.    }
  78.  
  79.    switch (cap) {
  80.       case GL_ALPHA_TEST:
  81.          if (ctx->Color.AlphaEnabled!=state) {
  82.             ctx->Color.AlphaEnabled = state;
  83.             ctx->NewState |= NEW_RASTER_OPS;
  84.          }
  85.      break;
  86.       case GL_AUTO_NORMAL:
  87.      ctx->Eval.AutoNormal = state;
  88.      break;
  89.       case GL_BLEND:
  90.          if (ctx->Color.BlendEnabled!=state) {
  91.             ctx->Color.BlendEnabled = state;
  92.             /* The following needed to accomodate 1.0 RGB logic op blending */
  93.             if (ctx->Color.BlendEquation==GL_LOGIC_OP && state) {
  94.                ctx->Color.ColorLogicOpEnabled = GL_TRUE;
  95.             }
  96.             else {
  97.                ctx->Color.ColorLogicOpEnabled = GL_FALSE;
  98.             }
  99.             ctx->NewState |= NEW_RASTER_OPS;
  100.          }
  101.      break;
  102.       case GL_CLIP_PLANE0:
  103.       case GL_CLIP_PLANE1:
  104.       case GL_CLIP_PLANE2:
  105.       case GL_CLIP_PLANE3:
  106.       case GL_CLIP_PLANE4:
  107.       case GL_CLIP_PLANE5:
  108.      ctx->Transform.ClipEnabled[cap-GL_CLIP_PLANE0] = state;
  109.      /* Check if any clip planes enabled */
  110.          ctx->Transform.AnyClip = GL_FALSE;
  111.          for (p=0;p<MAX_CLIP_PLANES;p++) {
  112.             if (ctx->Transform.ClipEnabled[p]) {
  113.                ctx->Transform.AnyClip = GL_TRUE;
  114.                break;
  115.             }
  116.          }
  117.      break;
  118.       case GL_COLOR_MATERIAL:
  119.          if (ctx->Light.ColorMaterialEnabled!=state) {
  120.             ctx->Light.ColorMaterialEnabled = state;
  121.             if (state) {
  122.                GLfloat color[4];
  123.                color[0] = ctx->Current.ByteColor[0] * (1.0F / 255.0F);
  124.                color[1] = ctx->Current.ByteColor[1] * (1.0F / 255.0F);
  125.                color[2] = ctx->Current.ByteColor[2] * (1.0F / 255.0F);
  126.                color[3] = ctx->Current.ByteColor[3] * (1.0F / 255.0F);
  127.                /* update material with current color */
  128.                gl_set_material( ctx, ctx->Light.ColorMaterialBitmask, color );
  129.             }
  130.             gl_set_color_function(ctx);
  131.             ctx->NewState |= NEW_LIGHTING;
  132.          }
  133.      break;
  134.       case GL_CULL_FACE:
  135.          if (ctx->Polygon.CullFlag!=state) {
  136.             ctx->Polygon.CullFlag = state;
  137.             ctx->NewState |= NEW_POLYGON;
  138.          }
  139.      break;
  140.       case GL_DEPTH_TEST:
  141.          if (state && ctx->Visual->DepthBits==0) {
  142.             gl_warning(ctx,"glEnable(GL_DEPTH_TEST) but no depth buffer");
  143.             return;
  144.          }
  145.      if (ctx->Depth.Test!=state) {
  146.             ctx->Depth.Test = state;
  147.             ctx->NewState |= NEW_RASTER_OPS;
  148.          }
  149.          break;
  150.       case GL_DITHER:
  151.          if (ctx->NoDither) {
  152.             /* MESA_NO_DITHER env var */
  153.             state = GL_FALSE;
  154.          }
  155.          if (ctx->Color.DitherFlag!=state) {
  156.             ctx->Color.DitherFlag = state;
  157.             ctx->NewState |= NEW_RASTER_OPS;
  158.          }
  159.      break;
  160.       case GL_FOG:
  161.      if (ctx->Fog.Enabled!=state) {
  162.             ctx->Fog.Enabled = state;
  163.             ctx->NewState |= NEW_RASTER_OPS;
  164.          }
  165.      break;
  166.       case GL_LIGHT0:
  167.       case GL_LIGHT1:
  168.       case GL_LIGHT2:
  169.       case GL_LIGHT3:
  170.       case GL_LIGHT4:
  171.       case GL_LIGHT5:
  172.       case GL_LIGHT6:
  173.       case GL_LIGHT7:
  174.          ctx->Light.Light[cap-GL_LIGHT0].Enabled = state;
  175.          ctx->NewState |= NEW_LIGHTING;
  176.          break;
  177.       case GL_LIGHTING:
  178.          if (ctx->Light.Enabled!=state) {
  179.             ctx->Light.Enabled = state;
  180.             ctx->NewState |= NEW_LIGHTING;
  181.          }
  182.          break;
  183.       case GL_LINE_SMOOTH:
  184.      if (ctx->Line.SmoothFlag!=state) {
  185.             ctx->Line.SmoothFlag = state;
  186.             ctx->NewState |= NEW_RASTER_OPS;
  187.          }
  188.      break;
  189.       case GL_LINE_STIPPLE:
  190.      if (ctx->Line.StippleFlag!=state) {
  191.             ctx->Line.StippleFlag = state;
  192.             ctx->NewState |= NEW_RASTER_OPS;
  193.          }
  194.      break;
  195.       case GL_INDEX_LOGIC_OP:
  196.          if (ctx->Color.IndexLogicOpEnabled!=state) {
  197.             ctx->NewState |= NEW_RASTER_OPS;
  198.          }
  199.      ctx->Color.IndexLogicOpEnabled = state;
  200.      break;
  201.       case GL_COLOR_LOGIC_OP:
  202.          if (ctx->Color.ColorLogicOpEnabled!=state) {
  203.             ctx->NewState |= NEW_RASTER_OPS;
  204.          }
  205.      ctx->Color.ColorLogicOpEnabled = state;
  206.      break;
  207.       case GL_MAP1_COLOR_4:
  208.      ctx->Eval.Map1Color4 = state;
  209.      break;
  210.       case GL_MAP1_INDEX:
  211.      ctx->Eval.Map1Index = state;
  212.      break;
  213.       case GL_MAP1_NORMAL:
  214.      ctx->Eval.Map1Normal = state;
  215.      break;
  216.       case GL_MAP1_TEXTURE_COORD_1:
  217.      ctx->Eval.Map1TextureCoord1 = state;
  218.      break;
  219.       case GL_MAP1_TEXTURE_COORD_2:
  220.      ctx->Eval.Map1TextureCoord2 = state;
  221.      break;
  222.       case GL_MAP1_TEXTURE_COORD_3:
  223.      ctx->Eval.Map1TextureCoord3 = state;
  224.      break;
  225.       case GL_MAP1_TEXTURE_COORD_4:
  226.      ctx->Eval.Map1TextureCoord4 = state;
  227.      break;
  228.       case GL_MAP1_VERTEX_3:
  229.      ctx->Eval.Map1Vertex3 = state;
  230.      break;
  231.       case GL_MAP1_VERTEX_4:
  232.      ctx->Eval.Map1Vertex4 = state;
  233.      break;
  234.       case GL_MAP2_COLOR_4:
  235.      ctx->Eval.Map2Color4 = state;
  236.      break;
  237.       case GL_MAP2_INDEX:
  238.      ctx->Eval.Map2Index = state;
  239.      break;
  240.       case GL_MAP2_NORMAL:
  241.      ctx->Eval.Map2Normal = state;
  242.      break;
  243.       case GL_MAP2_TEXTURE_COORD_1: 
  244.      ctx->Eval.Map2TextureCoord1 = state;
  245.      break;
  246.       case GL_MAP2_TEXTURE_COORD_2:
  247.      ctx->Eval.Map2TextureCoord2 = state;
  248.      break;
  249.       case GL_MAP2_TEXTURE_COORD_3:
  250.      ctx->Eval.Map2TextureCoord3 = state;
  251.      break;
  252.       case GL_MAP2_TEXTURE_COORD_4:
  253.      ctx->Eval.Map2TextureCoord4 = state;
  254.      break;
  255.       case GL_MAP2_VERTEX_3:
  256.      ctx->Eval.Map2Vertex3 = state;
  257.      break;
  258.       case GL_MAP2_VERTEX_4:
  259.      ctx->Eval.Map2Vertex4 = state;
  260.      break;
  261.       case GL_NORMALIZE:
  262.      ctx->Transform.Normalize = state;
  263.      break;
  264.       case GL_POINT_SMOOTH:
  265.      if (ctx->Point.SmoothFlag!=state) {
  266.             ctx->Point.SmoothFlag = state;
  267.             ctx->NewState |= NEW_RASTER_OPS;
  268.          }
  269.      break;
  270.       case GL_POLYGON_SMOOTH:
  271.      if (ctx->Polygon.SmoothFlag!=state) {
  272.             ctx->Polygon.SmoothFlag = state;
  273.             ctx->NewState |= NEW_RASTER_OPS;
  274.          }
  275.      break;
  276.       case GL_POLYGON_STIPPLE:
  277.      if (ctx->Polygon.StippleFlag!=state) {
  278.             ctx->Polygon.StippleFlag = state;
  279.             ctx->NewState |= NEW_RASTER_OPS;
  280.          }
  281.      break;
  282.       case GL_POLYGON_OFFSET_POINT:
  283.          if (ctx->Polygon.OffsetPoint!=state) {
  284.             ctx->Polygon.OffsetPoint = state;
  285.             ctx->NewState |= NEW_POLYGON;
  286.          }
  287.          break;
  288.       case GL_POLYGON_OFFSET_LINE:
  289.          if (ctx->Polygon.OffsetLine!=state) {
  290.             ctx->Polygon.OffsetLine = state;
  291.             ctx->NewState |= NEW_POLYGON;
  292.          }
  293.          break;
  294.       case GL_POLYGON_OFFSET_FILL:
  295.       /*case GL_POLYGON_OFFSET_EXT:*/
  296.          if (ctx->Polygon.OffsetFill!=state) {
  297.             ctx->Polygon.OffsetFill = state;
  298.             ctx->NewState |= NEW_POLYGON;
  299.          }
  300.          break;
  301.       case GL_RESCALE_NORMAL_EXT:
  302.          ctx->Transform.RescaleNormals = state;
  303.          break;
  304.       case GL_SCISSOR_TEST:
  305.          if (ctx->Scissor.Enabled!=state) {
  306.             ctx->Scissor.Enabled = state;
  307.             ctx->NewState |= NEW_RASTER_OPS;
  308.          }
  309.      break;
  310.       case GL_SHARED_TEXTURE_PALETTE_EXT:
  311.          ctx->Texture.SharedPalette = state;
  312.          if (ctx->Driver.UseGlobalTexturePalette)
  313.             (*ctx->Driver.UseGlobalTexturePalette)( ctx, state );
  314.          break;
  315.       case GL_STENCIL_TEST:
  316.      if (state && ctx->Visual->StencilBits==0) {
  317.             gl_warning(ctx, "glEnable(GL_STENCIL_TEST) but no stencil buffer");
  318.             return;
  319.      }
  320.      if (ctx->Stencil.Enabled!=state) {
  321.             ctx->Stencil.Enabled = state;
  322.             ctx->NewState |= NEW_RASTER_OPS;
  323.          }
  324.      break;
  325.       case GL_TEXTURE_1D:
  326.          if (ctx->Visual->RGBAflag) {
  327.             /* texturing only works in RGB mode */
  328.             GLuint bit = TEXTURE0_1D << (ctx->Texture.CurrentSet * 4);
  329.             if (state) {
  330.                ctx->Texture.Enabled |= bit;
  331.             }
  332.             else {
  333.                ctx->Texture.Enabled &= (~bit);
  334.             }
  335.             ctx->NewState |= (NEW_RASTER_OPS | NEW_TEXTURING);
  336.          }
  337.      break;
  338.       case GL_TEXTURE_2D:
  339.          if (ctx->Visual->RGBAflag) {
  340.             /* texturing only works in RGB mode */
  341.             GLuint bit = TEXTURE0_2D << (ctx->Texture.CurrentSet * 4);
  342.             if (state) {
  343.                ctx->Texture.Enabled |= bit;
  344.             }
  345.             else {
  346.                ctx->Texture.Enabled &= (~bit);
  347.             }
  348.             ctx->NewState |= (NEW_RASTER_OPS | NEW_TEXTURING);
  349.          }
  350.      break;
  351.       case GL_TEXTURE_3D_EXT:
  352.          if (ctx->Visual->RGBAflag) {
  353.             /* texturing only works in RGB mode */
  354.             GLuint bit = TEXTURE0_3D << (ctx->Texture.CurrentSet * 4);
  355.             if (state) {
  356.                ctx->Texture.Enabled |= bit;
  357.             }
  358.             else {
  359.                ctx->Texture.Enabled &= (~bit);
  360.             }
  361.             ctx->NewState |= (NEW_RASTER_OPS | NEW_TEXTURING);
  362.          }
  363.          break;
  364.       case GL_TEXTURE_GEN_Q:
  365.          if (state) {
  366.             ctx->Texture.Set[texSet].TexGenEnabled |= Q_BIT;
  367.          }
  368.          else {
  369.             ctx->Texture.Set[texSet].TexGenEnabled &= ~Q_BIT;
  370.          }
  371.          ctx->NewState |= NEW_TEXTURING;
  372.      break;
  373.       case GL_TEXTURE_GEN_R:
  374.          if (state) {
  375.             ctx->Texture.Set[texSet].TexGenEnabled |= R_BIT;
  376.          }
  377.          else {
  378.             ctx->Texture.Set[texSet].TexGenEnabled &= ~R_BIT;
  379.          }
  380.          ctx->NewState |= NEW_TEXTURING;
  381.      break;
  382.       case GL_TEXTURE_GEN_S:
  383.      if (state) {
  384.             ctx->Texture.Set[texSet].TexGenEnabled |= S_BIT;
  385.          }
  386.          else {
  387.             ctx->Texture.Set[texSet].TexGenEnabled &= ~S_BIT;
  388.          }
  389.          ctx->NewState |= NEW_TEXTURING;
  390.      break;
  391.       case GL_TEXTURE_GEN_T:
  392.          if (state) {
  393.             ctx->Texture.Set[texSet].TexGenEnabled |= T_BIT;
  394.          }
  395.          else {
  396.             ctx->Texture.Set[texSet].TexGenEnabled &= ~T_BIT;
  397.          }
  398.          ctx->NewState |= NEW_TEXTURING;
  399.      break;
  400.  
  401.       /*
  402.        * CLIENT STATE!!!
  403.        */
  404.       case GL_VERTEX_ARRAY:
  405.          ctx->Array.VertexEnabled = state;
  406.          break;
  407.       case GL_NORMAL_ARRAY:
  408.          ctx->Array.NormalEnabled = state;
  409.          break;
  410.       case GL_COLOR_ARRAY:
  411.          ctx->Array.ColorEnabled = state;
  412.          break;
  413.       case GL_INDEX_ARRAY:
  414.          ctx->Array.IndexEnabled = state;
  415.          break;
  416.       case GL_TEXTURE_COORD_ARRAY:
  417.          ctx->Array.TexCoordEnabled[ctx->TexCoordSet] = state;
  418.          break;
  419.       case GL_EDGE_FLAG_ARRAY:
  420.          ctx->Array.EdgeFlagEnabled = state;
  421.          break;
  422.  
  423.       default:
  424.      if (state) {
  425.         gl_error( ctx, GL_INVALID_ENUM, "glEnable" );
  426.      }
  427.      else {
  428.         gl_error( ctx, GL_INVALID_ENUM, "glDisable" );
  429.      }
  430.          break;
  431.    }
  432. }
  433.  
  434.  
  435.  
  436.  
  437. void gl_Enable( GLcontext* ctx, GLenum cap )
  438. {
  439.    gl_enable( ctx, cap, GL_TRUE );
  440. }
  441.  
  442.  
  443.  
  444. void gl_Disable( GLcontext* ctx, GLenum cap )
  445. {
  446.    gl_enable( ctx, cap, GL_FALSE );
  447. }
  448.  
  449.  
  450.  
  451. GLboolean gl_IsEnabled( GLcontext* ctx, GLenum cap )
  452. {
  453.    switch (cap) {
  454.       case GL_ALPHA_TEST:
  455.          return ctx->Color.AlphaEnabled;
  456.       case GL_AUTO_NORMAL:
  457.      return ctx->Eval.AutoNormal;
  458.       case GL_BLEND:
  459.          return ctx->Color.BlendEnabled;
  460.       case GL_CLIP_PLANE0:
  461.       case GL_CLIP_PLANE1:
  462.       case GL_CLIP_PLANE2:
  463.       case GL_CLIP_PLANE3:
  464.       case GL_CLIP_PLANE4:
  465.       case GL_CLIP_PLANE5:
  466.      return ctx->Transform.ClipEnabled[cap-GL_CLIP_PLANE0];
  467.       case GL_COLOR_MATERIAL:
  468.      return ctx->Light.ColorMaterialEnabled;
  469.       case GL_CULL_FACE:
  470.          return ctx->Polygon.CullFlag;
  471.       case GL_DEPTH_TEST:
  472.          return ctx->Depth.Test;
  473.       case GL_DITHER:
  474.      return ctx->Color.DitherFlag;
  475.       case GL_FOG:
  476.      return ctx->Fog.Enabled;
  477.       case GL_LIGHTING:
  478.          return ctx->Light.Enabled;
  479.       case GL_LIGHT0:
  480.       case GL_LIGHT1:
  481.       case GL_LIGHT2:
  482.       case GL_LIGHT3:
  483.       case GL_LIGHT4:
  484.       case GL_LIGHT5:
  485.       case GL_LIGHT6:
  486.       case GL_LIGHT7:
  487.          return ctx->Light.Light[cap-GL_LIGHT0].Enabled;
  488.       case GL_LINE_SMOOTH:
  489.      return ctx->Line.SmoothFlag;
  490.       case GL_LINE_STIPPLE:
  491.      return ctx->Line.StippleFlag;
  492.       case GL_INDEX_LOGIC_OP:
  493.      return ctx->Color.IndexLogicOpEnabled;
  494.       case GL_COLOR_LOGIC_OP:
  495.      return ctx->Color.ColorLogicOpEnabled;
  496.       case GL_MAP1_COLOR_4:
  497.      return ctx->Eval.Map1Color4;
  498.       case GL_MAP1_INDEX:
  499.      return ctx->Eval.Map1Index;
  500.       case GL_MAP1_NORMAL:
  501.      return ctx->Eval.Map1Normal;
  502.       case GL_MAP1_TEXTURE_COORD_1:
  503.      return ctx->Eval.Map1TextureCoord1;
  504.       case GL_MAP1_TEXTURE_COORD_2:
  505.      return ctx->Eval.Map1TextureCoord2;
  506.       case GL_MAP1_TEXTURE_COORD_3:
  507.      return ctx->Eval.Map1TextureCoord3;
  508.       case GL_MAP1_TEXTURE_COORD_4:
  509.      return ctx->Eval.Map1TextureCoord4;
  510.       case GL_MAP1_VERTEX_3:
  511.      return ctx->Eval.Map1Vertex3;
  512.       case GL_MAP1_VERTEX_4:
  513.      return ctx->Eval.Map1Vertex4;
  514.       case GL_MAP2_COLOR_4:
  515.      return ctx->Eval.Map2Color4;
  516.       case GL_MAP2_INDEX:
  517.      return ctx->Eval.Map2Index;
  518.       case GL_MAP2_NORMAL:
  519.      return ctx->Eval.Map2Normal;
  520.       case GL_MAP2_TEXTURE_COORD_1: 
  521.      return ctx->Eval.Map2TextureCoord1;
  522.       case GL_MAP2_TEXTURE_COORD_2:
  523.      return ctx->Eval.Map2TextureCoord2;
  524.       case GL_MAP2_TEXTURE_COORD_3:
  525.      return ctx->Eval.Map2TextureCoord3;
  526.       case GL_MAP2_TEXTURE_COORD_4:
  527.      return ctx->Eval.Map2TextureCoord4;
  528.       case GL_MAP2_VERTEX_3:
  529.      return ctx->Eval.Map2Vertex3;
  530.       case GL_MAP2_VERTEX_4:
  531.      return ctx->Eval.Map2Vertex4;
  532.       case GL_NORMALIZE:
  533.      return ctx->Transform.Normalize;
  534.       case GL_POINT_SMOOTH:
  535.      return ctx->Point.SmoothFlag;
  536.       case GL_POLYGON_SMOOTH:
  537.      return ctx->Polygon.SmoothFlag;
  538.       case GL_POLYGON_STIPPLE:
  539.      return ctx->Polygon.StippleFlag;
  540.       case GL_POLYGON_OFFSET_POINT:
  541.      return ctx->Polygon.OffsetPoint;
  542.       case GL_POLYGON_OFFSET_LINE:
  543.      return ctx->Polygon.OffsetLine;
  544.       case GL_POLYGON_OFFSET_FILL:
  545.       /*case GL_POLYGON_OFFSET_EXT:*/
  546.      return ctx->Polygon.OffsetFill;
  547.       case GL_RESCALE_NORMAL_EXT:
  548.          return ctx->Transform.RescaleNormals;
  549.       case GL_SCISSOR_TEST:
  550.      return ctx->Scissor.Enabled;
  551.       case GL_SHARED_TEXTURE_PALETTE_EXT:
  552.          return ctx->Texture.SharedPalette;
  553.       case GL_STENCIL_TEST:
  554.      return ctx->Stencil.Enabled;
  555.       case GL_TEXTURE_1D:
  556.          {
  557.             GLuint bit = TEXTURE0_1D << (ctx->Texture.CurrentSet * 4);
  558.             return (ctx->Texture.Enabled & bit) ? GL_TRUE : GL_FALSE;
  559.          }
  560.       case GL_TEXTURE_2D:
  561.          {
  562.             GLuint bit = TEXTURE0_1D << (ctx->Texture.CurrentSet * 4);
  563.             return (ctx->Texture.Enabled & bit) ? GL_TRUE : GL_FALSE;
  564.          }
  565.       case GL_TEXTURE_3D_EXT:
  566.          {
  567.             GLuint bit = TEXTURE0_1D << (ctx->Texture.CurrentSet * 4);
  568.             return (ctx->Texture.Enabled & bit) ? GL_TRUE : GL_FALSE;
  569.          }
  570.       case GL_TEXTURE_GEN_Q:
  571.          {
  572.             const struct gl_texture_set *texSet = &ctx->Texture.Set[ctx->Texture.CurrentSet];
  573.             return (texSet->TexGenEnabled & Q_BIT) ? GL_TRUE : GL_FALSE;
  574.          }
  575.       case GL_TEXTURE_GEN_R:
  576.          {
  577.             const struct gl_texture_set *texSet = &ctx->Texture.Set[ctx->Texture.CurrentSet];
  578.             return (texSet->TexGenEnabled & R_BIT) ? GL_TRUE : GL_FALSE;
  579.          }
  580.       case GL_TEXTURE_GEN_S:
  581.          {
  582.             const struct gl_texture_set *texSet = &ctx->Texture.Set[ctx->Texture.CurrentSet];
  583.             return (texSet->TexGenEnabled & S_BIT) ? GL_TRUE : GL_FALSE;
  584.          }
  585.       case GL_TEXTURE_GEN_T:
  586.          {
  587.             const struct gl_texture_set *texSet = &ctx->Texture.Set[ctx->Texture.CurrentSet];
  588.             return (texSet->TexGenEnabled & T_BIT) ? GL_TRUE : GL_FALSE;
  589.          }
  590.  
  591.       /*
  592.        * CLIENT STATE!!!
  593.        */
  594.       case GL_VERTEX_ARRAY:
  595.          return ctx->Array.VertexEnabled;
  596.       case GL_NORMAL_ARRAY:
  597.          return ctx->Array.NormalEnabled;
  598.       case GL_COLOR_ARRAY:
  599.          return ctx->Array.ColorEnabled;
  600.       case GL_INDEX_ARRAY:
  601.          return ctx->Array.IndexEnabled;
  602.       case GL_TEXTURE_COORD_ARRAY:
  603.          return ctx->Array.TexCoordEnabled[ctx->TexCoordSet];
  604.       case GL_EDGE_FLAG_ARRAY:
  605.          return ctx->Array.EdgeFlagEnabled;
  606.       default:
  607.      gl_error( ctx, GL_INVALID_ENUM, "glIsEnabled" );
  608.      return GL_FALSE;
  609.    }
  610. }
  611.  
  612.  
  613.  
  614.  
  615. void gl_client_state( GLcontext *ctx, GLenum cap, GLboolean state )
  616. {
  617.    switch (cap) {
  618.       case GL_VERTEX_ARRAY:
  619.          ctx->Array.VertexEnabled = state;
  620.          break;
  621.       case GL_NORMAL_ARRAY:
  622.          ctx->Array.NormalEnabled = state;
  623.          break;
  624.       case GL_COLOR_ARRAY:
  625.          ctx->Array.ColorEnabled = state;
  626.          break;
  627.       case GL_INDEX_ARRAY:
  628.          ctx->Array.IndexEnabled = state;
  629.          break;
  630.       case GL_TEXTURE_COORD_ARRAY:
  631.          ctx->Array.TexCoordEnabled[ctx->TexCoordSet] = state;
  632.          break;
  633.       case GL_EDGE_FLAG_ARRAY:
  634.          ctx->Array.EdgeFlagEnabled = state;
  635.          break;
  636.       default:
  637.          gl_error( ctx, GL_INVALID_ENUM, "glEnable/DisableClientState" );
  638.    }
  639. }
  640.  
  641.  
  642.  
  643. void gl_EnableClientState( GLcontext *ctx, GLenum cap )
  644. {
  645.    gl_client_state( ctx, cap, GL_TRUE );
  646. }
  647.  
  648.  
  649.  
  650. void gl_DisableClientState( GLcontext *ctx, GLenum cap )
  651. {
  652.    gl_client_state( ctx, cap, GL_FALSE );
  653. }
  654.  
  655.